/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.beanutils; import java.beans.PropertyDescriptor; import java.lang.ref.Reference; import java.lang.ref.SoftReference; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; import java.util.WeakHashMap; /** * <p>Implementation of <code>DynaClass</code> for DynaBeans that wrap * standard JavaBean instances.</p> * * <p> * It is suggested that this class should not usually need to be used directly * to create new <code>WrapDynaBean</code> instances. * It's usually better to call the <code>WrapDynaBean</code> constructor directly. * For example:</p> * <code><pre> * Object javaBean = ...; * DynaBean wrapper = new WrapDynaBean(javaBean); * </pre></code> * <p> * * @author Craig McClanahan * @version $Revision: 690380 $ $Date: 2008-08-29 21:04:38 +0100 (Fri, 29 Aug 2008) $ */ public class WrapDynaClass implements DynaClass { // ----------------------------------------------------------- Constructors /** * Construct a new WrapDynaClass for the specified JavaBean class. This * constructor is private; WrapDynaClass instances will be created as * needed via calls to the <code>createDynaClass(Class)</code> method. * * @param beanClass JavaBean class to be introspected around */ private WrapDynaClass(Class beanClass) { this.beanClassRef = new SoftReference(beanClass); this.beanClassName = beanClass.getName(); introspect(); } // ----------------------------------------------------- Instance Variables /** * Name of the JavaBean class represented by this WrapDynaClass. */ private String beanClassName = null; /** * Reference to the JavaBean class represented by this WrapDynaClass. */ private Reference beanClassRef = null; /** * The JavaBean <code>Class</code> which is represented by this * <code>WrapDynaClass</code>. * * @deprecated No longer initialized, use getBeanClass() method instead */ protected Class beanClass = null; /** * The set of PropertyDescriptors for this bean class. */ protected PropertyDescriptor[] descriptors = null; /** * The set of PropertyDescriptors for this bean class, keyed by the * property name. Individual descriptor instances will be the same * instances as those in the <code>descriptors</code> list. */ protected HashMap descriptorsMap = new HashMap(); /** * The set of dynamic properties that are part of this DynaClass. */ protected DynaProperty[] properties = null; /** * The set of dynamic properties that are part of this DynaClass, * keyed by the property name. Individual descriptor instances will * be the same instances as those in the <code>properties</code> list. */ protected HashMap propertiesMap = new HashMap(); // ------------------------------------------------------- Static Variables private static final ContextClassLoaderLocal CLASSLOADER_CACHE = new ContextClassLoaderLocal() { protected Object initialValue() { return new WeakHashMap(); } }; /** * Get the wrap dyna classes cache */ private static Map getDynaClassesMap() { return (Map)CLASSLOADER_CACHE.get(); } /** * The set of <code>WrapDynaClass</code> instances that have ever been * created, keyed by the underlying bean Class. The keys to this map * are Class objects, and the values are corresponding WrapDynaClass * objects. * <p> * This static variable is safe even when this code is deployed via a * shared classloader because it is keyed via a Class object. The same * class loaded via two different classloaders will result in different * entries in this map. * <p> * Note, however, that this HashMap can result in a memory leak. When * this class is in a shared classloader it will retain references to * classes loaded via a webapp classloader even after the webapp has been * undeployed. That will prevent the entire classloader and all the classes * it refers to and all their static members from being freed. * ************* !!!!!!!!!!!! PLEASE NOTE !!!!!!!!!!!! ************* * * THE FOLLOWING IS A NASTY HACK TO SO THAT BEANUTILS REMAINS BINARY * COMPATIBLE WITH PREVIOUS RELEASES. * * There are two issues here: * * 1) Memory Issues: The static HashMap caused memory problems (See BEANUTILS-59) * to resolve this it has been moved into a ContextClassLoaderLocal instance * (named CLASSLOADER_CACHE above) which holds one copy per * ClassLoader in a WeakHashMap. * * 2) Binary Compatibility: As the "dynaClasses" static HashMap is "protected" * removing it breaks BeanUtils binary compatibility with previous versions. * To resolve this all the methods have been overriden to delegate to the * Map for the ClassLoader in the ContextClassLoaderLocal. * * @deprecated The dynaClasses Map will be removed in a subsequent release */ protected static HashMap dynaClasses = new HashMap() { public void clear() { getDynaClassesMap().clear(); } public boolean containsKey(Object key) { return getDynaClassesMap().containsKey(key); } public boolean containsValue(Object value) { return getDynaClassesMap().containsValue(value); } public Set entrySet() { return getDynaClassesMap().entrySet(); } public boolean equals(Object o) { return getDynaClassesMap().equals(o); } public Object get(Object key) { return getDynaClassesMap().get(key); } public int hashCode() { return getDynaClassesMap().hashCode(); } public boolean isEmpty() { return getDynaClassesMap().isEmpty(); } public Set keySet() { return getDynaClassesMap().keySet(); } public Object put(Object key, Object value) { return getDynaClassesMap().put(key, value); } public void putAll(Map m) { getDynaClassesMap().putAll(m); } public Object remove(Object key) { return getDynaClassesMap().remove(key); } public int size() { return getDynaClassesMap().size(); } public Collection values() { return getDynaClassesMap().values(); } }; // ------------------------------------------------------ DynaClass Methods /** * Return the class of the underlying wrapped bean. * * @return the class of the underlying wrapped bean * @since 1.8.0 */ protected Class getBeanClass() { return (Class)beanClassRef.get(); } /** * Return the name of this DynaClass (analogous to the * <code>getName()</code> method of <code>java.lang.Class</code), which * allows the same <code>DynaClass</code> implementation class to support * different dynamic classes, with different sets of properties. * * @return the name of the DynaClass */ public String getName() { return beanClassName; } /** * Return a property descriptor for the specified property, if it exists; * otherwise, return <code>null</code>. * * @param name Name of the dynamic property for which a descriptor * is requested * @return The descriptor for the specified property * * @exception IllegalArgumentException if no property name is specified */ public DynaProperty getDynaProperty(String name) { if (name == null) { throw new IllegalArgumentException ("No property name specified"); } return ((DynaProperty) propertiesMap.get(name)); } /** * <p>Return an array of <code>ProperyDescriptors</code> for the properties * currently defined in this DynaClass. If no properties are defined, a * zero-length array will be returned.</p> * * <p><strong>FIXME</strong> - Should we really be implementing * <code>getBeanInfo()</code> instead, which returns property descriptors * and a bunch of other stuff?</p> * * @return the set of properties for this DynaClass */ public DynaProperty[] getDynaProperties() { return (properties); } /** * <p>Instantiates a new standard JavaBean instance associated with * this DynaClass and return it wrapped in a new WrapDynaBean * instance. <strong>NOTE</strong> the JavaBean should have a * no argument constructor.</p> * * <strong>NOTE</strong> - Most common use cases should not need to use * this method. It is usually better to create new * <code>WrapDynaBean</code> instances by calling its constructor. * For example:</p> * <code><pre> * Object javaBean = ...; * DynaBean wrapper = new WrapDynaBean(javaBean); * </pre></code> * <p> * (This method is needed for some kinds of <code>DynaBean</code> framework.) * </p> * * @return A new <code>DynaBean</code> instance * @exception IllegalAccessException if the Class or the appropriate * constructor is not accessible * @exception InstantiationException if this Class represents an abstract * class, an array class, a primitive type, or void; or if instantiation * fails for some other reason */ public DynaBean newInstance() throws IllegalAccessException, InstantiationException { return new WrapDynaBean(getBeanClass().newInstance()); } // --------------------------------------------------------- Public Methods /** * Return the PropertyDescriptor for the specified property name, if any; * otherwise return <code>null</code>. * * @param name Name of the property to be retrieved * @return The descriptor for the specified property */ public PropertyDescriptor getPropertyDescriptor(String name) { return ((PropertyDescriptor) descriptorsMap.get(name)); } // --------------------------------------------------------- Static Methods /** * Clear our cache of WrapDynaClass instances. */ public static void clear() { getDynaClassesMap().clear(); } /** * Create (if necessary) and return a new <code>WrapDynaClass</code> * instance for the specified bean class. * * @param beanClass Bean class for which a WrapDynaClass is requested * @return A new <i>Wrap</i> {@link DynaClass} */ public static WrapDynaClass createDynaClass(Class beanClass) { WrapDynaClass dynaClass = (WrapDynaClass) getDynaClassesMap().get(beanClass); if (dynaClass == null) { dynaClass = new WrapDynaClass(beanClass); getDynaClassesMap().put(beanClass, dynaClass); } return (dynaClass); } // ------------------------------------------------------ Protected Methods /** * Introspect our bean class to identify the supported properties. */ protected void introspect() { // Look up the property descriptors for this bean class Class beanClass = getBeanClass(); PropertyDescriptor[] regulars = PropertyUtils.getPropertyDescriptors(beanClass); if (regulars == null) { regulars = new PropertyDescriptor[0]; } Map mappeds = PropertyUtils.getMappedPropertyDescriptors(beanClass); if (mappeds == null) { mappeds = new HashMap(); } // Construct corresponding DynaProperty information properties = new DynaProperty[regulars.length + mappeds.size()]; for (int i = 0; i < regulars.length; i++) { descriptorsMap.put(regulars[i].getName(), regulars[i]); properties[i] = new DynaProperty(regulars[i].getName(), regulars[i].getPropertyType()); propertiesMap.put(properties[i].getName(), properties[i]); } int j = regulars.length; Iterator names = mappeds.keySet().iterator(); while (names.hasNext()) { String name = (String) names.next(); PropertyDescriptor descriptor = (PropertyDescriptor) mappeds.get(name); properties[j] = new DynaProperty(descriptor.getName(), Map.class); propertiesMap.put(properties[j].getName(), properties[j]); j++; } } }